# 1.写函数,将传入的列表或元祖对象的奇数位索引对应的元素
'''
def test1(list_:list or tuple):
    result = []
    for i  in range(len(list_)):
        if i%2 !=0:
            result.append(list_[i])
    return result
a =  test1([1,2,3,4,5])
print(a)
'''
# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
'''
def test2(char:str or list or tuple):
    if len(char) > 5:
        return "大于5"
    else:
        return "不大于5"
test2('我是一个测试文本')
print(test2('我是一个测试文本'))
print(test2([1,2,3,4,5]))
'''
# 3.写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
'''
def  test3(doc:str):
    abc = 0
    numb = 0
    space = 0
    other = 0
    for i in doc:
        if i >= "a" and i <= 'z' or i >= 'A' and i <= 'Z':
            abc += 1
        elif i in "012346789":
            numb += 1
        elif i == " ":
            space += 1
        else:
            other += 1
    print('字母的个数：%d，数字的个数：%d，空格的个数：%d，其他内容的个数：%d' % (abc, numb, space, other))
test3('15654asdasdf')
'''
# 4.写函数,接收两个数字参数,返回较大的那个数字
'''
def test5(num1,num2):
    if num1 > num2:
        return num1
    else: 
        return num2
result = test5(6,7)
print(result)
'''
# 5.编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
'''
def cacluate(*args):
    return tuple(args)
result = cacluate(1,2,3,4)
print(result)
'''
# 6.编写一个函数,接收字符串参数,返回一个元组,元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
'''
def test6(char:str):
    A = []
    a = []
    for i in char :
        if i >='A' and i <='Z':
            A.append(i)
        elif i >= 'a' and i  <='z':
            a.append(i)
    num1 = len(A)
    num2 =  len(a)
    return tuple([num1,num2])
result = test6('ASDASDAFASFASFsfasdfasdfasdfadf')
print(result)
'''
# 7.编写函数, 接收一个列表(包含30个1~100之间的随机整形数)和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
'''
import random
def test7(lst,k):
    if k<0 or k>len(lst):
        return lst
    lst[:k] = lst[:k][::-1]
    lst[k:] = lst[k:][::-1]
    return lst
result = test7([random.randint(1,100)for i in range(30)],15)
print(result)
'''
# 8.编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
'''
def calculate(x, n):
    series = 0
    for i in range(1, n + 1):
        series += int(str(x) * i)
    return series
x = int(input("请输入数字x: "))
n = int(input("请输入项数n: "))
result = calculate(x, n)
print(f"前{n}项的值是: {result}")
'''
# 9.写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
'''
def person(name,age,address,sex='男'):
    person = {
        '姓名': name,
        '性别': sex,
        '年龄': age,
        '地址': address
    }
    return person
print(person('李四','6','沈阳','男'))
'''
# 10.写函数,接收n个数字,返回这些数字的和(动态传参)
'''
def numbers(*args):
    return sum(args)
result = numbers(1, 2, 3, 4, 5)
print(result)
'''
# 11.在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
'''
def box(*args):
    print(*args,*kwargs)
'''
# 12.写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
'''
def underscore(lst):
    return [str(i) + "_" for i in lst]
print(underscore([1,2,3,4]))
'''
# 13.写函数,传入一个数字,返回这个数的阶乘。示例：1x2x3....
'''
def num(n:int):
    if n == 0:
        return 1
    else:
        return n * num(n- 1)
result = num(5)
print(result)
'''
# 14写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
# 15.编写函数，求1+2+3+…N的和
'''
def sum_num(num):
    n = 1
    if num == n :
        return num
    else:
        return num + sum_num(num-1)
result= sum_num(29)
print(result)
'''
# 16.编写一个函数，求多个数中的最大值
'''
def max_num(*args):
    return max(args)
print(max_num(15,156,1,3,1,65,1,3,21))
'''
# 17.编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串

# 18.写一个函数，求多个数的平均值
'''
def average(*args):  
    return sum(args) / len(args)
    '''


# 19.写一个自己的len函数，统计指定序列中元素的个数
'''
#20.
def count_(elements):
    count = 0
    for i in elements:
        if i in elements:
            count += 1
    return count
result = count_([1,23,2])
print(result)
'''
#20.找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
'''
def test1(list_:list or tuple):
    result = []
    for i  in range(len(list_)):
        if i%2 !=0:
            result.append(list_[i])
    return result
a =  test1([1,2,3,4,5])
print(a)
'''
#21.水仙花数：个位、十位、百位的立方加在一起等于数的本身
'''
def num_():
    for num in range(100,999):
        a,b,c = map(int, str(num))
        if num == a**3 + b**3 + c**3:
            print(num)
print(num_())
'''
#22.定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
#数组中的每个元素值不允许超过 100，但是可以等于100，
#如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
#删除所有重复元素，使得每个元素只出现一次
#按照数字的大小，由高到低排序返回
'''
def list1(lst:list):
    lst = lst[:100]
    lst2 = []
    while True:
     for i in lst:
        if i not in lst2 and i <= 100:
                lst2.append(i)
        else :
              return lst2
result = list1([100,100,12,12,1231,1321,122,199,99,88,77,66,55])
print(result)
'''
#23.定义函数 getLength，打印用户传入的容器类型和数据长度
'''
def getLength(N):
    print(type(N))
    print(len(N))
'''
#24.

#25.

'''
def morethan(num):
    num = int(input('请输入数字'))
    if num > 1500 :
        print('大于1500')
        '''
#26.
def num(x,y):

    for i in range(x,y):
        sum_ = i**2
        sum_num = 0
        sum_num = sum_num + sum_
        return sum_num
result = num(1,2)
print(result)
#27.写函数，检查传入字典的每一个value长度，如果大于2，
#那么仅保留前两个长度的内容， 并将新内容返回给调用者
'''
def dict_(_dict):  
    _dict = {}  
    for key, value in _dict.items():  
        if len(value) > 2:  
            _dict[key] = value[:2]  
        else:  
            _dict[key] = value  
    return _dict
    '''
#28.
'''
def check_(obj):
    if obj == None:
        print('对象为空')
#29.编写自定义函数，完成一个简单的减法运算函数
def subtract(num1, num2):
    return num1 - num2
#30.编写自定义函数，可以输出自己的名字即可。
def name():
    print('liyuhao')
    '''
#31.编写自定义函数：剪刀石头布
#游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。

 #当用户为 0 分时，游戏结束，提示游戏结束，比赛输了

#当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数

#1 代表剪刀 2 代表石头 3 代表布
import  random
def play_game():
    user_score = 100
    computer_score = 100

    while user_score > 0 and computer_score > 0:

            user_choice = int(input("请出拳 (1-剪刀, 2-石头, 3-布): "))
            computer_choice = random.randint(1, 3)


            if user_choice == 1 and computer_choice == 3:
                computer_score -= 10
                user_score += 10
                print('玩家出 剪刀，电脑出 布')
            elif user_choice == 1 and computer_choice == 2:
                computer_score += 10
                user_score -= 10
                print('玩家出 剪刀，电脑出 石头')
            elif user_choice == 2 and computer_choice == 1:
                user_score += 10
                computer_score -= 10
                print('玩家出 石头，电脑出 剪刀')
            elif user_choice == 2 and computer_choice == 3:
                user_score -= 10
                computer_score += 10
                print('玩家出 石头，电脑出 布')
            elif user_choice == 3 and computer_choice == 1:
                user_score -= 10
                computer_score += 10
                print('玩家出 布，电脑出 剪刀')
            elif user_choice == 3 and computer_choice == 2:
                user_score += 10
                computer_score -= 10
                print('玩家出 布，电脑出 石头')
            else :
                print('平局')
            print(f"当前分数: 用户 {user_score}, 电脑 {computer_score}")


    if user_score == 0:
        print("游戏结束，比赛输了！")
    elif user_score == 200:
        print("游戏结束，赢得比赛！")



play_game()




'''
#32.编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
def string(str1):
    return str1[::-1]
'''
#33.编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
'''
def string(str2):
    str3 = []
    for i in str2:
        if i%2 == 0:
            str3.append(i)
    return str3
'''
'''
#34.编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
def longest(string_list):
    long = string_list[0]
    for i in string_list:
        if len(i) > len(long):
            long = string
    return long
'''
#35.编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
'''def sum_sq(numb):
    return sum(x**2 for x in numb)
'''
#36.编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
'''def capitalize_words(string):
    words = string.split('')
    for i in range(len(words)):
        words[i] = words[i][0].upper() + words[i][1:]
    capitalized_string = ' '.join(words)
    return capitalized_string
'''
#37.编写一个函数，接受两个列表作为参数，并返回两个列表的交集
'''
def intersection(list1, list2):
    set1 = set(list1)
    set2 = set(list2)
    return list(set1 & set2)
'''
#38.定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市

'''def stu(name, gender, age, city):
    print("姓名: ", name)
    print("性别: ", gender)
    print("年龄: ", age)
    print("城市: ", city)
    '''